import javax.lang.model.type.ArrayType;
import javax.swing.*;
import java.util.Arrays;

public class Test {
    public static void main(String[] args) {
    //可能存在的异常 越界异常 null指针异常(空指针异常)
//        int[] array = {1,2,3,4,5};
//        System.out.println(array[0]);
        //java内存划分 JVM : 虚拟空间栈 :存放变量位置
        // 本地空间栈：存放了C/C++实现的静态办法
        // 堆：开辟存放变量得空间
        // 方法区 ：存储已被虚拟机加载的数据 信息...即编译器编译后的代码
        // 程序计数器：存放下一个执行方法的地址 即记忆下次从那里开始运行代码
        //遍历数组方法
        //1.简单遍历
        //int[] array = {1,2,3,4,5};
//        for(int i = 0;i < array.length;i++) {
//            System.out.print(array[i] + " ");
//        }
        //2.or each   (数组数据类型 重命名名称: 数组名)
        //无法获取数组下标 仅仅可以用来打印数组
//        for (int x:array) {
//            System.out.print(x + " ");
//        }
        //3.类方法 Arrays.toString(数组名) 把数组元素转换为字符串打印
//        String ret = Arrays.toString(array);
//        System.out.println(ret);

        //基本引用类型 和 引用数据类型
//        int a = 10;//在空间中直接放的是其对应的值
//        int[] array1 = {1,2,3,4,5};//引用数据类型 存放引用类型对象在空间上对应的地址

        //认识null 当执行null 或 数组不再指向对象时 对于堆上空间被释放
        //int[] arr = null;
        //指向为空时 不能进行任何操作 否则将会报出空指针错误

        //作为函数的参数
//        int[] array = {1,2,3,4,5};
//        print(array);
//    }
//    public static void print(int[] array) {
//        for (int i = 0; i < array.length; i++) {
//            System.out.print(array[i] + " ");
//      }
//        int[] array = {1,2,3,4,5};
//        func1(array);
//        System.out.println(Arrays.toString(array));
//        func2(array);
//        System.out.println(Arrays.toString(array));
//   }
//   public static void func1(int[] array) {// 1 2 3 4 5
//        array = new int[]{11,22,33,44,55};//在堆上面新建了一个空间 故打印不变
//   }
//   public static void func2(int[] array) {//99 2 3 4 5
//        array[0] = 99;//通过数组下标修改值 故打印 99 2 3 4 5
       //引用变量指向对象
        //传基本数据类型做参数 不能改变值
//        int x = 0;
//        func(x);
//        System.out.println(x);
        //传引用数据类型 根据情况而定

//        //作为函数返回值
//        int[] ret = func();
//        System.out.println(Arrays.toString(ret));

        //获取斐波那契数列
//        int[] ret = fib(10);
//        System.out.println(Arrays.toString(ret));

        //模拟数组转字符串
        //int[] array = {1,2,3,4,5};
//        int[] array = null;
//        String ret = myToString(array);
//        System.out.println(ret);

        //数组拷贝
        //方法一 依次拷贝
//        int[] array = {1,2,3,4,5};
//        int[] copy = new int[array.length];
//        for(int i = 0;i < array.length;i++) {
//            copy[i] = array[i];
//        }
//        System.out.println(Arrays.toString(copy));
        //方法二 方法拷贝 copyOf(拷贝那个数组,要拷贝多少) 如果该数组需要扩容 直接拷贝长度*倍数即可
//        int[] array = {1,2,3,4,5};
//       int[] copy = Arrays.copyOf(array,array.length);
//        System.out.println(Arrays.toString(copy));
        //扩容
//        int[] array = {1,2,3,4,5};
//        array = Arrays.copyOf(array,array.length*2);
//        System.out.println(Arrays.toString(array));
        //指定拷贝部分copyOfRange(数组名称,从哪里开始拷贝,到哪里结束)
//        int[] array = {1,2,3,4,5};
//        int[] copy = Arrays.copyOfRange(array,0,2);//指定范围为左闭右开
//        System.out.println(Arrays.toString(copy));
        //方法三 使用本地方法打印arraycopy(被拷贝数组,被拷贝数组开始位置,拷贝数组,拷贝数组位置,拷贝长度)
//        int[] array = {1,2,3,4,5};
//        int[] dest = new int[array.length];
//        System.arraycopy(array,0,dest,0,array.length);
//        System.out.println(Arrays.toString(dest));
        //方法四 克隆
//        int[] array = {1,2,3,4,5};
//        int[] copy = new int[array.length];
//        copy = array.clone();
//        System.out.println(Arrays.toString(copy));

        //求数组中的平均数
//        int[] array = {1,2,3,4,5};
//        System.out.println(average(array));

        //查找
//        int[] array = {11,33,22,44,55};
//        int i = find(array,66);
//        System.out.println(i);//返回下标
        //二分查找:只能查找有序数组
        //类方法 Arrays.binarySearch(要查找的数组,查找的数组中的数字);
//        int[] array = {11,33,22,44,55};
//        Arrays.sort(array);
//        System.out.println(Arrays.toString(array));
//        int i = binarySearch(array,88);
//        System.out.println(i);

        //方法 Arrays.fill(数组名,全部填充为数)/Arrays.fill(数组名,开始填充位置,末尾填充位置,填充数)
//        int[] array = new int[10];
//        Arrays.fill(array,99);
//        System.out.println(Arrays.toString(array));
//        Arrays.fill(array,0,3,99);//左闭右开
//        System.out.println(Arrays.toString(array));
        //逆序数组
//        int[] array = {1,2,3,4,5};
//        int[] ret = reverse(array);
//        System.out.println(Arrays.toString(ret));

        //冒泡排序
        int[] array = {11,33,22,44,55};
        int[] ret = bubblesort(array);
        System.out.println(Arrays.toString(ret));
    }

    //冒泡排序
    public static int[] bubblesort(int[] array) {
        boolean flag = false;
        for (int i = 0; i < array.length - 1; i++) {
            for(int j = 0;j < array.length - i - 1;j++) {
                if(array[j] > array[j + 1]) {
                    int tmp = array[j];
                    array[j] = array[j + 1];
                    array[j + 1] = tmp;
                    flag = true;
                }
            }
            if( flag == false) {
               break;
            }
        }
        return array;
    }
//两两交换法
//    public static int[] reverse(int[] array) {
//        int left = 0;
//        int right = array.length - 1;
//        while(left < right) {
//            int tmp = array[left];
//            array[left] = array[right];
//            array[right] = tmp;
//            left++;//++
//            right--;//--
//        }
//        return array;
//    }

//遍历数组
//    public static int find(int[] array,int key) {
//        for(int i = 0;i < array.length;i++) {
//            if(key == array[i]) {
//                return i;
//            }
//        }
//        return -1;
//    }
    //二分查找
//    public static int binarySearch(int[] array,int key) {
//        int left = 0;
//        int right = array.length - 1;
//        while(left <= right) {//相等也取中间值
//            int mid = (left + right) / 2;//放在里面 循环减半
//            if(array[mid] < key) {//小了 left = mid + 1;
//                left = mid + 1;
//            }else if(array[mid] == key) {
//                return mid;
//            }else {//大了 right = mid - 1;
//                right = mid - 1;
//            }
//         }
//        return -1;//实行代码使用了 -(right + 1)
//    }

//    public static double average(int[] array) {
//        double sum = 0;
//        for (int i = 0;i < array.length;i++) {
//            sum += array[i];
//        }
//        return (double)sum / (double)(array.length);
//    }

//    public static String myToString(int[] array) {
//        if(array == null) {
//            return "null";
//        }
//        String ret = "[";
//        for(int i = 0;i < array.length;i++) {
//            ret += array[i];
//            if(i != array.length - 1) {
//                ret += ",";
//            }
//        }
//        ret += "]";
//        return ret;
//    }
//    public static int[] fib(int n) {
//        if(n <= 0) {
//            return null;
//        }
//        //循环求值
//        int[] array = new int[n];
//        array[0] = array[1] = 1;
//        for(int i = 2;i <= n - 1;i++) {
//            array[i] = array[i - 1] + array[i - 2];
//        }
//        return array;
//    }

//    public static int[] func() {
//        int[] array = {1,2,3,4,5};
//        return array;
//    }

//   public  static void func(int x) {
//        x = 20;
//       System.out.println(x);
//   }
}
